home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 22 / PCPP #22.iso / Quake2 / q2source_12_11 / utils3 / qe4 / lbmlib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-17  |  16.4 KB  |  814 lines
  1. // lbmlib.c
  2.  
  3. #include "cmdlib.h"
  4. #include "lbmlib.h"
  5.  
  6.  
  7.  
  8. /*
  9. ============================================================================
  10.  
  11.                         LBM STUFF
  12.  
  13. ============================================================================
  14. */
  15.  
  16.  
  17. typedef unsigned char    UBYTE;
  18. //conflicts with windows typedef short            WORD;
  19. typedef unsigned short    UWORD;
  20. typedef long            LONG;
  21.  
  22. typedef enum
  23. {
  24.     ms_none,
  25.     ms_mask,
  26.     ms_transcolor,
  27.     ms_lasso
  28. } mask_t;
  29.  
  30. typedef enum
  31. {
  32.     cm_none,
  33.     cm_rle1
  34. } compress_t;
  35.  
  36. typedef struct
  37. {
  38.     UWORD        w,h;
  39.     short        x,y;
  40.     UBYTE        nPlanes;
  41.     UBYTE        masking;
  42.     UBYTE        compression;
  43.     UBYTE        pad1;
  44.     UWORD        transparentColor;
  45.     UBYTE        xAspect,yAspect;
  46.     short        pageWidth,pageHeight;
  47. } bmhd_t;
  48.  
  49. extern    bmhd_t    bmhd;                        // will be in native byte order
  50.  
  51.  
  52.  
  53. #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
  54. #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
  55. #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
  56. #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
  57. #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
  58. #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
  59.  
  60.  
  61. bmhd_t  bmhd;
  62.  
  63. int    Align (int l)
  64. {
  65.     if (l&1)
  66.         return l+1;
  67.     return l;
  68. }
  69.  
  70.  
  71.  
  72. /*
  73. ================
  74. LBMRLEdecompress
  75.  
  76. Source must be evenly aligned!
  77. ================
  78. */
  79. byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
  80. {
  81.     int     count;
  82.     byte    b,rept;
  83.  
  84.     count = 0;
  85.  
  86.     do
  87.     {
  88.         rept = *source++;
  89.  
  90.         if (rept > 0x80)
  91.         {
  92.             rept = (rept^0xff)+2;
  93.             b = *source++;
  94.             memset(unpacked,b,rept);
  95.             unpacked += rept;
  96.         }
  97.         else if (rept < 0x80)
  98.         {
  99.             rept++;
  100.             memcpy(unpacked,source,rept);
  101.             unpacked += rept;
  102.             source += rept;
  103.         }
  104.         else
  105.             rept = 0;               // rept of 0x80 is NOP
  106.  
  107.         count += rept;
  108.  
  109.     } while (count<bpwidth);
  110.  
  111.     if (count>bpwidth)
  112.         Error ("Decompression exceeded width!\n");
  113.  
  114.  
  115.     return source;
  116. }
  117.  
  118.  
  119. /*
  120. =================
  121. LoadLBM
  122. =================
  123. */
  124. void LoadLBM (char *filename, byte **picture, byte **palette)
  125. {
  126.     byte    *LBMbuffer, *picbuffer, *cmapbuffer;
  127.     int             y;
  128.     byte    *LBM_P, *LBMEND_P;
  129.     byte    *pic_p;
  130.     byte    *body_p;
  131.  
  132.     int    formtype,formlength;
  133.     int    chunktype,chunklength;
  134.  
  135. // qiet compiler warnings
  136.     picbuffer = NULL;
  137.     cmapbuffer = NULL;
  138.  
  139. //
  140. // load the LBM
  141. //
  142.     LoadFile (filename, (void **)&LBMbuffer);
  143.  
  144. //
  145. // parse the LBM header
  146. //
  147.     LBM_P = LBMbuffer;
  148.     if ( *(int *)LBMbuffer != LittleLong(FORMID) )
  149.        Error ("No FORM ID at start of file!\n");
  150.  
  151.     LBM_P += 4;
  152.     formlength = BigLong( *(int *)LBM_P );
  153.     LBM_P += 4;
  154.     LBMEND_P = LBM_P + Align(formlength);
  155.  
  156.     formtype = LittleLong(*(int *)LBM_P);
  157.  
  158.     if (formtype != ILBMID && formtype != PBMID)
  159.         Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
  160.         ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
  161.  
  162.     LBM_P += 4;
  163.  
  164. //
  165. // parse chunks
  166. //
  167.  
  168.     while (LBM_P < LBMEND_P)
  169.     {
  170.         chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
  171.         LBM_P += 4;
  172.         chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
  173.         LBM_P += 4;
  174.  
  175.         switch ( chunktype )
  176.         {
  177.         case BMHDID:
  178.             memcpy (&bmhd,LBM_P,sizeof(bmhd));
  179.             bmhd.w = BigShort(bmhd.w);
  180.             bmhd.h = BigShort(bmhd.h);
  181.             bmhd.x = BigShort(bmhd.x);
  182.             bmhd.y = BigShort(bmhd.y);
  183.             bmhd.pageWidth = BigShort(bmhd.pageWidth);
  184.             bmhd.pageHeight = BigShort(bmhd.pageHeight);
  185.             break;
  186.  
  187.         case CMAPID:
  188.             cmapbuffer = malloc (768);
  189.             memset (cmapbuffer, 0, 768);
  190.             memcpy (cmapbuffer, LBM_P, chunklength);
  191.             break;
  192.  
  193.         case BODYID:
  194.             body_p = LBM_P;
  195.  
  196.             pic_p = picbuffer = malloc (bmhd.w*bmhd.h);
  197.             if (formtype == PBMID)
  198.             {
  199.             //
  200.             // unpack PBM
  201.             //
  202.                 for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
  203.                 {
  204.                     if (bmhd.compression == cm_rle1)
  205.                         body_p = LBMRLEDecompress ((byte *)body_p
  206.                         , pic_p , bmhd.w);
  207.                     else if (bmhd.compression == cm_none)
  208.                     {
  209.                         memcpy (pic_p,body_p,bmhd.w);
  210.                         body_p += Align(bmhd.w);
  211.                     }
  212.                 }
  213.  
  214.             }
  215.             else
  216.             {
  217.             //
  218.             // unpack ILBM
  219.             //
  220.                 Error ("%s is an interlaced LBM, not packed", filename);
  221.             }
  222.             break;
  223.         }
  224.  
  225.         LBM_P += Align(chunklength);
  226.     }
  227.  
  228.     free (LBMbuffer);
  229.  
  230.     *picture = picbuffer;
  231.  
  232.     if (palette)
  233.         *palette = cmapbuffer;
  234. }
  235.  
  236.  
  237. /*
  238. ============================================================================
  239.  
  240.                             WRITE LBM
  241.  
  242. ============================================================================
  243. */
  244.  
  245. /*
  246. ==============
  247. WriteLBMfile
  248. ==============
  249. */
  250. void WriteLBMfile (char *filename, byte *data,
  251.                    int width, int height, byte *palette)
  252. {
  253.     byte    *lbm, *lbmptr;
  254.     int    *formlength, *bmhdlength, *cmaplength, *bodylength;
  255.     int    length;
  256.     bmhd_t  basebmhd;
  257.  
  258.     lbm = lbmptr = malloc (width*height+1000);
  259.  
  260. //
  261. // start FORM
  262. //
  263.     *lbmptr++ = 'F';
  264.     *lbmptr++ = 'O';
  265.     *lbmptr++ = 'R';
  266.     *lbmptr++ = 'M';
  267.  
  268.     formlength = (int*)lbmptr;
  269.     lbmptr+=4;                      // leave space for length
  270.  
  271.     *lbmptr++ = 'P';
  272.     *lbmptr++ = 'B';
  273.     *lbmptr++ = 'M';
  274.     *lbmptr++ = ' ';
  275.  
  276. //
  277. // write BMHD
  278. //
  279.     *lbmptr++ = 'B';
  280.     *lbmptr++ = 'M';
  281.     *lbmptr++ = 'H';
  282.     *lbmptr++ = 'D';
  283.  
  284.     bmhdlength = (int *)lbmptr;
  285.     lbmptr+=4;                      // leave space for length
  286.  
  287.     memset (&basebmhd,0,sizeof(basebmhd));
  288.     basebmhd.w = BigShort((short)width);
  289.     basebmhd.h = BigShort((short)height);
  290.     basebmhd.nPlanes = 8;
  291.     basebmhd.xAspect = 5;
  292.     basebmhd.yAspect = 6;
  293.     basebmhd.pageWidth = BigShort((short)width);
  294.     basebmhd.pageHeight = BigShort((short)height);
  295.  
  296.     memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
  297.     lbmptr += sizeof(basebmhd);
  298.  
  299.     length = lbmptr-(byte *)bmhdlength-4;
  300.     *bmhdlength = BigLong(length);
  301.     if (length&1)
  302.         *lbmptr++ = 0;          // pad chunk to even offset
  303.  
  304. //
  305. // write CMAP
  306. //
  307.     *lbmptr++ = 'C';
  308.     *lbmptr++ = 'M';
  309.     *lbmptr++ = 'A';
  310.     *lbmptr++ = 'P';
  311.  
  312.     cmaplength = (int *)lbmptr;
  313.     lbmptr+=4;                      // leave space for length
  314.  
  315.     memcpy (lbmptr,palette,768);
  316.     lbmptr += 768;
  317.  
  318.     length = lbmptr-(byte *)cmaplength-4;
  319.     *cmaplength = BigLong(length);
  320.     if (length&1)
  321.         *lbmptr++ = 0;          // pad chunk to even offset
  322.  
  323. //
  324. // write BODY
  325. //
  326.     *lbmptr++ = 'B';
  327.     *lbmptr++ = 'O';
  328.     *lbmptr++ = 'D';
  329.     *lbmptr++ = 'Y';
  330.  
  331.     bodylength = (int *)lbmptr;
  332.     lbmptr+=4;                      // leave space for length
  333.  
  334.     memcpy (lbmptr,data,width*height);
  335.     lbmptr += width*height;
  336.  
  337.     length = lbmptr-(byte *)bodylength-4;
  338.     *bodylength = BigLong(length);
  339.     if (length&1)
  340.         *lbmptr++ = 0;          // pad chunk to even offset
  341.  
  342. //
  343. // done
  344. //
  345.     length = lbmptr-(byte *)formlength-4;
  346.     *formlength = BigLong(length);
  347.     if (length&1)
  348.         *lbmptr++ = 0;          // pad chunk to even offset
  349.  
  350. //
  351. // write output file
  352. //
  353.     SaveFile (filename, lbm, lbmptr-lbm);
  354.     free (lbm);
  355. }
  356.  
  357.  
  358. /*
  359. ============================================================================
  360.  
  361. LOAD PCX
  362.  
  363. ============================================================================
  364. */
  365.  
  366. typedef struct
  367. {
  368.     char    manufacturer;
  369.     char    version;
  370.     char    encoding;
  371.     char    bits_per_pixel;
  372.     unsigned short    xmin,ymin,xmax,ymax;
  373.     unsigned short    hres,vres;
  374.     unsigned char    palette[48];
  375.     char    reserved;
  376.     char    color_planes;
  377.     unsigned short    bytes_per_line;
  378.     unsigned short    palette_type;
  379.     char    filler[58];
  380.     unsigned char    data;            // unbounded
  381. } pcx_t;
  382.  
  383.  
  384. /*
  385. ==============
  386. LoadPCX
  387. ==============
  388. */
  389. void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
  390. {
  391.     byte    *raw;
  392.     pcx_t    *pcx;
  393.     int        x, y;
  394.     int        len;
  395.     int        dataByte, runLength;
  396.     byte    *out, *pix;
  397.  
  398.     if (pic)
  399.         *pic = NULL;
  400.     if (palette)
  401.         *palette = NULL;
  402.     if (width)
  403.         *width = 0;
  404.     if (height)
  405.         *height = 0;
  406.  
  407.     //
  408.     // load the file
  409.     //
  410.     len = LoadFile (filename, (void **)&raw);
  411.     if (len == -1)
  412.         return;
  413.  
  414.     //
  415.     // parse the PCX file
  416.     //
  417.     pcx = (pcx_t *)raw;
  418.     raw = &pcx->data;
  419.  
  420.     pcx->xmin = LittleShort(pcx->xmin);
  421.     pcx->ymin = LittleShort(pcx->ymin);
  422.     pcx->xmax = LittleShort(pcx->xmax);
  423.     pcx->ymax = LittleShort(pcx->ymax);
  424.     pcx->hres = LittleShort(pcx->hres);
  425.     pcx->vres = LittleShort(pcx->vres);
  426.     pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  427.     pcx->palette_type = LittleShort(pcx->palette_type);
  428.  
  429.     if (pcx->manufacturer != 0x0a
  430.         || pcx->version != 5
  431.         || pcx->encoding != 1
  432.         || pcx->bits_per_pixel != 8
  433.         || pcx->xmax >= 640
  434.         || pcx->ymax >= 480)
  435.         Error ("Bad pcx file %s", filename);
  436.     
  437.     if (palette)
  438.     {
  439.         *palette = malloc(768);
  440.         memcpy (*palette, (byte *)pcx + len - 768, 768);
  441.     }
  442.  
  443.     if (width)
  444.         *width = pcx->xmax+1;
  445.     if (height)
  446.         *height = pcx->ymax+1;
  447.  
  448.     if (!pic)
  449.         return;
  450.  
  451.     out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
  452.     if (!out)
  453.         Error ("Skin_Cache: couldn't allocate");
  454.  
  455.     *pic = out;
  456.  
  457.     pix = out;
  458.  
  459.     for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
  460.     {
  461.         for (x=0 ; x<=pcx->xmax ; )
  462.         {
  463.             dataByte = *raw++;
  464.  
  465.             if((dataByte & 0xC0) == 0xC0)
  466.             {
  467.                 runLength = dataByte & 0x3F;
  468.                 dataByte = *raw++;
  469.             }
  470.             else
  471.                 runLength = 1;
  472.  
  473.             while(runLength-- > 0)
  474.                 pix[x++] = dataByte;
  475.         }
  476.  
  477.     }
  478.  
  479.     if ( raw - (byte *)pcx > len)
  480.         Error ("PCX file %s was malformed", filename);
  481.  
  482.     free (pcx);
  483. }
  484.  
  485. /* 
  486. ============== 
  487. WritePCXfile 
  488. ============== 
  489. */ 
  490. void WritePCXfile (char *filename, byte *data, 
  491.                    int width, int height, byte *palette) 
  492. {
  493.     int        i, j, length;
  494.     pcx_t    *pcx;
  495.     byte        *pack;
  496.       
  497.     pcx = malloc (width*height*2+1000);
  498.     memset (pcx, 0, sizeof(*pcx));
  499.  
  500.     pcx->manufacturer = 0x0a;    // PCX id
  501.     pcx->version = 5;            // 256 color
  502.      pcx->encoding = 1;        // uncompressed
  503.     pcx->bits_per_pixel = 8;        // 256 color
  504.     pcx->xmin = 0;
  505.     pcx->ymin = 0;
  506.     pcx->xmax = LittleShort((short)(width-1));
  507.     pcx->ymax = LittleShort((short)(height-1));
  508.     pcx->hres = LittleShort((short)width);
  509.     pcx->vres = LittleShort((short)height);
  510.     pcx->color_planes = 1;        // chunky image
  511.     pcx->bytes_per_line = LittleShort((short)width);
  512.     pcx->palette_type = LittleShort(2);        // not a grey scale
  513.  
  514.     // pack the image
  515.     pack = &pcx->data;
  516.     
  517.     for (i=0 ; i<height ; i++)
  518.     {
  519.         for (j=0 ; j<width ; j++)
  520.         {
  521.             if ( (*data & 0xc0) != 0xc0)
  522.                 *pack++ = *data++;
  523.             else
  524.             {
  525.                 *pack++ = 0xc1;
  526.                 *pack++ = *data++;
  527.             }
  528.         }
  529.     }
  530.             
  531.     // write the palette
  532.     *pack++ = 0x0c;    // palette ID byte
  533.     for (i=0 ; i<768 ; i++)
  534.         *pack++ = *palette++;
  535.         
  536. // write output file 
  537.     length = pack - (byte *)pcx;
  538.     SaveFile (filename, pcx, length);
  539.  
  540.     free (pcx);
  541. } 
  542.  
  543.  
  544. /*
  545. ============================================================================
  546.  
  547. LOAD IMAGE
  548.  
  549. ============================================================================
  550. */
  551.  
  552. /*
  553. ==============
  554. Load256Image
  555.  
  556. Will load either an lbm or pcx, depending on extension.
  557. Any of the return pointers can be NULL if you don't want them.
  558. ==============
  559. */
  560. void Load256Image (char *name, byte **pixels, byte **palette,
  561.                    int *width, int *height)
  562. {
  563.     char    ext[128];
  564.  
  565.     ExtractFileExtension (name, ext);
  566.     if (!Q_strcasecmp (ext, "lbm"))
  567.     {
  568.         LoadLBM (name, pixels, palette);
  569.         if (width)
  570.             *width = bmhd.w;
  571.         if (height)
  572.             *height = bmhd.h;
  573.     }
  574.     else if (!Q_strcasecmp (ext, "pcx"))
  575.     {
  576.         LoadPCX (name, pixels, palette, width, height);
  577.     }
  578.     else
  579.         Error ("%s doesn't have a known image extension", name);
  580. }
  581.  
  582.  
  583. /*
  584. ==============
  585. Save256Image
  586.  
  587. Will save either an lbm or pcx, depending on extension.
  588. ==============
  589. */
  590. void Save256Image (char *name, byte *pixels, byte *palette,
  591.                    int width, int height)
  592. {
  593.     char    ext[128];
  594.  
  595.     ExtractFileExtension (name, ext);
  596.     if (!Q_strcasecmp (ext, "lbm"))
  597.     {
  598.         WriteLBMfile (name, pixels, width, height, palette);
  599.     }
  600.     else if (!Q_strcasecmp (ext, "pcx"))
  601.     {
  602.         WritePCXfile (name, pixels, width, height, palette);
  603.     }
  604.     else
  605.         Error ("%s doesn't have a known image extension", name);
  606. }
  607.  
  608.  
  609.  
  610.  
  611. /*
  612. ============================================================================
  613.  
  614. TARGA IMAGE
  615.  
  616. ============================================================================
  617. */
  618.  
  619. typedef struct _TargaHeader {
  620.     unsigned char     id_length, colormap_type, image_type;
  621.     unsigned short    colormap_index, colormap_length;
  622.     unsigned char    colormap_size;
  623.     unsigned short    x_origin, y_origin, width, height;
  624.     unsigned char    pixel_size, attributes;
  625. } TargaHeader;
  626.  
  627. int fgetLittleShort (FILE *f)
  628. {
  629.     byte    b1, b2;
  630.  
  631.     b1 = fgetc(f);
  632.     b2 = fgetc(f);
  633.  
  634.     return (short)(b1 + b2*256);
  635. }
  636.  
  637. int fgetLittleLong (FILE *f)
  638. {
  639.     byte    b1, b2, b3, b4;
  640.  
  641.     b1 = fgetc(f);
  642.     b2 = fgetc(f);
  643.     b3 = fgetc(f);
  644.     b4 = fgetc(f);
  645.  
  646.     return b1 + (b2<<8) + (b3<<16) + (b4<<24);
  647. }
  648.  
  649.  
  650. /*
  651. =============
  652. LoadTGA
  653. =============
  654. */
  655. void LoadTGA (char *name, byte **pixels, int *width, int *height)
  656. {
  657.     int                columns, rows, numPixels;
  658.     byte            *pixbuf;
  659.     int                row, column;
  660.     FILE            *fin;
  661.     byte            *targa_rgba;
  662.     TargaHeader        targa_header;
  663.  
  664.     fin = fopen (name, "rb");
  665.     if (!fin)
  666.         Error ("Couldn't read %s", name);
  667.  
  668.     targa_header.id_length = fgetc(fin);
  669.     targa_header.colormap_type = fgetc(fin);
  670.     targa_header.image_type = fgetc(fin);
  671.     
  672.     targa_header.colormap_index = fgetLittleShort(fin);
  673.     targa_header.colormap_length = fgetLittleShort(fin);
  674.     targa_header.colormap_size = fgetc(fin);
  675.     targa_header.x_origin = fgetLittleShort(fin);
  676.     targa_header.y_origin = fgetLittleShort(fin);
  677.     targa_header.width = fgetLittleShort(fin);
  678.     targa_header.height = fgetLittleShort(fin);
  679.     targa_header.pixel_size = fgetc(fin);
  680.     targa_header.attributes = fgetc(fin);
  681.  
  682.     if (targa_header.image_type!=2 
  683.         && targa_header.image_type!=10) 
  684.         Error ("LoadTGA: Only type 2 and 10 targa RGB images supported\n");
  685.  
  686.     if (targa_header.colormap_type !=0 
  687.         || (targa_header.pixel_size!=32 && targa_header.pixel_size!=24))
  688.         Error ("Texture_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
  689.  
  690.     columns = targa_header.width;
  691.     rows = targa_header.height;
  692.     numPixels = columns * rows;
  693.  
  694.     if (width)
  695.         *width = columns;
  696.     if (height)
  697.         *height = rows;
  698.     targa_rgba = malloc(numPixels*4);
  699.     *pixels = targa_rgba;
  700.  
  701.     if (targa_header.id_length != 0)
  702.         fseek(fin, targa_header.id_length, SEEK_CUR);  // skip TARGA image comment
  703.     
  704.     if (targa_header.image_type==2) {  // Uncompressed, RGB images
  705.         for(row=rows-1; row>=0; row--) {
  706.             pixbuf = targa_rgba + row*columns*4;
  707.             for(column=0; column<columns; column++) {
  708.                 unsigned char red,green,blue,alphabyte;
  709.                 switch (targa_header.pixel_size) {
  710.                     case 24:
  711.                             
  712.                             blue = getc(fin);
  713.                             green = getc(fin);
  714.                             red = getc(fin);
  715.                             *pixbuf++ = red;
  716.                             *pixbuf++ = green;
  717.                             *pixbuf++ = blue;
  718.                             *pixbuf++ = 255;
  719.                             break;
  720.                     case 32:
  721.                             blue = getc(fin);
  722.                             green = getc(fin);
  723.                             red = getc(fin);
  724.                             alphabyte = getc(fin);
  725.                             *pixbuf++ = red;
  726.                             *pixbuf++ = green;
  727.                             *pixbuf++ = blue;
  728.                             *pixbuf++ = alphabyte;
  729.                             break;
  730.                 }
  731.             }
  732.         }
  733.     }
  734.     else if (targa_header.image_type==10) {   // Runlength encoded RGB images
  735.         unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
  736.         for(row=rows-1; row>=0; row--) {
  737.             pixbuf = targa_rgba + row*columns*4;
  738.             for(column=0; column<columns; ) {
  739.                 packetHeader=getc(fin);
  740.                 packetSize = 1 + (packetHeader & 0x7f);
  741.                 if (packetHeader & 0x80) {        // run-length packet
  742.                     switch (targa_header.pixel_size) {
  743.                         case 24:
  744.                                 blue = getc(fin);
  745.                                 green = getc(fin);
  746.                                 red = getc(fin);
  747.                                 alphabyte = 255;
  748.                                 break;
  749.                         case 32:
  750.                                 blue = getc(fin);
  751.                                 green = getc(fin);
  752.                                 red = getc(fin);
  753.                                 alphabyte = getc(fin);
  754.                                 break;
  755.                     }
  756.     
  757.                     for(j=0;j<packetSize;j++) {
  758.                         *pixbuf++=red;
  759.                         *pixbuf++=green;
  760.                         *pixbuf++=blue;
  761.                         *pixbuf++=alphabyte;
  762.                         column++;
  763.                         if (column==columns) { // run spans across rows
  764.                             column=0;
  765.                             if (row>0)
  766.                                 row--;
  767.                             else
  768.                                 goto breakOut;
  769.                             pixbuf = targa_rgba + row*columns*4;
  770.                         }
  771.                     }
  772.                 }
  773.                 else {                            // non run-length packet
  774.                     for(j=0;j<packetSize;j++) {
  775.                         switch (targa_header.pixel_size) {
  776.                             case 24:
  777.                                     blue = getc(fin);
  778.                                     green = getc(fin);
  779.                                     red = getc(fin);
  780.                                     *pixbuf++ = red;
  781.                                     *pixbuf++ = green;
  782.                                     *pixbuf++ = blue;
  783.                                     *pixbuf++ = 255;
  784.                                     break;
  785.                             case 32:
  786.                                     blue = getc(fin);
  787.                                     green = getc(fin);
  788.                                     red = getc(fin);
  789.                                     alphabyte = getc(fin);
  790.                                     *pixbuf++ = red;
  791.                                     *pixbuf++ = green;
  792.                                     *pixbuf++ = blue;
  793.                                     *pixbuf++ = alphabyte;
  794.                                     break;
  795.                         }
  796.                         column++;
  797.                         if (column==columns) { // pixel packet run spans across rows
  798.                             column=0;
  799.                             if (row>0)
  800.                                 row--;
  801.                             else
  802.                                 goto breakOut;
  803.                             pixbuf = targa_rgba + row*columns*4;
  804.                         }                        
  805.                     }
  806.                 }
  807.             }
  808.             breakOut:;
  809.         }
  810.     }
  811.     
  812.     fclose(fin);
  813. }
  814.